{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T02:25:35.645724Z",
     "start_time": "2025-03-09T02:25:23.302823Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt # 导入matplotlib\n",
    "# %matplotlib inline  # 使matplotlib在Jupyter Notebook中显示图像\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.9.1\n",
      "numpy 2.0.0\n",
      "pandas 2.2.2\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 准备数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-09T02:25:41.122932Z",
     "start_time": "2025-03-09T02:25:35.645724Z"
    }
   },
   "source": [
    "from tensorflow import keras  #这里的波浪线不用管\n",
    "\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words=vocab_size, index_from=index_from)"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "source": [
    "type(train_labels)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.740408Z",
     "start_time": "2025-03-08T08:03:27.735449Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "code",
   "source": [
    "print(type(train_data))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.744409Z",
     "start_time": "2025-03-08T08:03:27.741414Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.750743Z",
     "start_time": "2025-03-08T08:03:27.744409Z"
    }
   },
   "cell_type": "code",
   "source": "train_data.shape  #每个样本是一段话，每个单词用一个数字表示",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "source": [
    "type(train_data[0])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.756583Z",
     "start_time": "2025-03-08T08:03:27.750743Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.763638Z",
     "start_time": "2025-03-08T08:03:27.756583Z"
    }
   },
   "cell_type": "code",
   "source": "train_data[2]   # 数据都放了开头BOS：0但是没有放0",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 14,\n",
       " 47,\n",
       " 8,\n",
       " 30,\n",
       " 31,\n",
       " 7,\n",
       " 4,\n",
       " 249,\n",
       " 108,\n",
       " 7,\n",
       " 4,\n",
       " 5974,\n",
       " 54,\n",
       " 61,\n",
       " 369,\n",
       " 13,\n",
       " 71,\n",
       " 149,\n",
       " 14,\n",
       " 22,\n",
       " 112,\n",
       " 4,\n",
       " 2401,\n",
       " 311,\n",
       " 12,\n",
       " 16,\n",
       " 3711,\n",
       " 33,\n",
       " 75,\n",
       " 43,\n",
       " 1829,\n",
       " 296,\n",
       " 4,\n",
       " 86,\n",
       " 320,\n",
       " 35,\n",
       " 534,\n",
       " 19,\n",
       " 263,\n",
       " 4821,\n",
       " 1301,\n",
       " 4,\n",
       " 1873,\n",
       " 33,\n",
       " 89,\n",
       " 78,\n",
       " 12,\n",
       " 66,\n",
       " 16,\n",
       " 4,\n",
       " 360,\n",
       " 7,\n",
       " 4,\n",
       " 58,\n",
       " 316,\n",
       " 334,\n",
       " 11,\n",
       " 4,\n",
       " 1716,\n",
       " 43,\n",
       " 645,\n",
       " 662,\n",
       " 8,\n",
       " 257,\n",
       " 85,\n",
       " 1200,\n",
       " 42,\n",
       " 1228,\n",
       " 2578,\n",
       " 83,\n",
       " 68,\n",
       " 3912,\n",
       " 15,\n",
       " 36,\n",
       " 165,\n",
       " 1539,\n",
       " 278,\n",
       " 36,\n",
       " 69,\n",
       " 2,\n",
       " 780,\n",
       " 8,\n",
       " 106,\n",
       " 14,\n",
       " 6905,\n",
       " 1338,\n",
       " 18,\n",
       " 6,\n",
       " 22,\n",
       " 12,\n",
       " 215,\n",
       " 28,\n",
       " 610,\n",
       " 40,\n",
       " 6,\n",
       " 87,\n",
       " 326,\n",
       " 23,\n",
       " 2300,\n",
       " 21,\n",
       " 23,\n",
       " 22,\n",
       " 12,\n",
       " 272,\n",
       " 40,\n",
       " 57,\n",
       " 31,\n",
       " 11,\n",
       " 4,\n",
       " 22,\n",
       " 47,\n",
       " 6,\n",
       " 2307,\n",
       " 51,\n",
       " 9,\n",
       " 170,\n",
       " 23,\n",
       " 595,\n",
       " 116,\n",
       " 595,\n",
       " 1352,\n",
       " 13,\n",
       " 191,\n",
       " 79,\n",
       " 638,\n",
       " 89,\n",
       " 2,\n",
       " 14,\n",
       " 9,\n",
       " 8,\n",
       " 106,\n",
       " 607,\n",
       " 624,\n",
       " 35,\n",
       " 534,\n",
       " 6,\n",
       " 227,\n",
       " 7,\n",
       " 129,\n",
       " 113]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.770742Z",
     "start_time": "2025-03-08T08:03:27.763638Z"
    }
   },
   "cell_type": "code",
   "source": "len(train_data[0])",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "218"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.776770Z",
     "start_time": "2025-03-08T08:03:27.770742Z"
    }
   },
   "cell_type": "code",
   "source": "len(train_data[1])",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "189"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": [
    "train_labels[0:10]  #二分类"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.783280Z",
     "start_time": "2025-03-08T08:03:27.777776Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0, 1, 0, 0, 1, 0, 1, 0])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"train\", len(train_data), train_labels.shape)  #25000个样本，每个样本是一段话，每个单词用一个数字表示\n",
    "print(\"test\", len(test_data), test_labels.shape)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.788737Z",
     "start_time": "2025-03-08T08:03:27.783280Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 25000 (25000,)\n",
      "test 25000 (25000,)\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.836697Z",
     "start_time": "2025-03-08T08:03:27.788737Z"
    }
   },
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()  # 拿到词表，已经做好了索引\n",
    "print(len(word_index))  # 打印词表长度\n",
    "print(type(word_index)) # 打印类型\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造 word2idx 和 idx2word"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.852724Z",
     "start_time": "2025-03-08T08:03:27.836697Z"
    }
   },
   "source": [
    "# 每一个词表都要有两个映射，一个单词到id，一个id到单词\n",
    "# 做一个单词到id的映射\n",
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}  # 0,1,2,3空出来做别的事,这里的idx是从1开始的,所以加3\n",
    "# 填充token，开始和结束符号，未知token\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,  # 填充 token\n",
    "    \"[BOS]\": 1,  # begin of sentence\n",
    "    \"[UNK]\": 2,  # 未知 token\n",
    "    \"[EOS]\": 3,  # end of sentence\n",
    "})\n",
    "\n",
    "# 再做一个id到单词的映射\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}  # 反向词典,id变为单词"
   ],
   "outputs": [],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "source": "print(word2idx[\"world\"])",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.858751Z",
     "start_time": "2025-03-08T08:03:27.853237Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "182\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "source": "idx2word[4]",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:27.864714Z",
     "start_time": "2025-03-08T08:03:27.858751Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:28.503060Z",
     "start_time": "2025-03-08T08:03:27.864714Z"
    }
   },
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "#统计样本中每个长度出现的次数\n",
    "for text in train_data:\n",
    "    length = len(text)  #句子长度\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1  #统计长度的频率\n",
    "\n",
    "# 固定最大长度\n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())  #长度分布图\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")  #画一条线，可以看到大部分都在500以内\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "source": [
    "#想对句子长度画个直方图，看看长度分布\n",
    "length_list = [len(text) for text in train_data]\n",
    "plt.hist(length_list, bins=50)\n",
    "plt.xlabel(\"length\")\n",
    "plt.ylabel(\"frequency\")\n",
    "# axvline画一条垂直线，可以看到大部分都在500以内\n",
    "plt.axvline(500, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:28.594748Z",
     "start_time": "2025-03-08T08:03:28.503566Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGwCAYAAABIC3rIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABLNElEQVR4nO3deVxUZf8//tesCMqAG1uCkphC4oIWTC5lcotJ9+1WaZIrahqaiFvclWn1CbPUKFMrTazbJe1OK81d0TTcSHJLckHRZDEVxg1mO98//HF+zs2QoANnOPN6Ph7zeJw518WZ9zki5z3XdZ3rUgiCIICIiIjIhSmlDoCIiIhIakyIiIiIyOUxISIiIiKXx4SIiIiIXB4TIiIiInJ5TIiIiIjI5TEhIiIiIpenljqA2sBqteLSpUvw9PSEQqGQOhwiIiKqBEEQcP36dQQEBECp/Ps2ICZElXDp0iUEBgZKHQYRERHdhwsXLqBJkyZ/W4cJUSV4enoCuHNBdTqdxNEQERFRZRgMBgQGBor38b/DhKgSyrrJdDodEyIiIqJapjLDXZgQkaxZLBbs27cPABAVFQWVSiVxRERE5IyYEJGsWSwWbNu2DQDw2GOPMSEiIiK7mBCRrCmVSrRt21bcJiIisocJEcmaWq1Gnz59pA6DiGqAxWKByWSSOgyqYVqt1iFfeJkQERFRrSYIAvLz81FUVCR1KCQBpVKJ4OBgaLXaBzoOEyIiIqrVypIhHx8feHh4cAJdF1I2cXJeXh6CgoIe6N+eCRHJmtFoxNy5cwEASUlJD/wNgoici8ViEZOhhg0bSh0OSaBx48a4dOkSzGYzNBrNfR+HCRHJXmlpqdQhEFE1KRsz5OHhIXEkJJWyL7oWi4UJEVFFNBoNxo0bJ24TkTyxm8x1OerfngkRyZpCoWAzOhER3RMnZiEiIiKXx4SIZM1iseDAgQM4cOAALBaL1OEQETklhUKBdevWSR0GAGDGjBlo165djX8uEyKSNYvFgo0bN2Ljxo1MiIiInIwzJWIcQ0SyplQqERYWJm4TERHZwzsEyZparcbzzz+P559/Hmo1838iV2I0GmE0GiEIgrjPYrHAaDTCbDY7vG5VPfXUUxg/fjwSExNRv359+Pr64osvvsDNmzcxfPhweHp6IiQkBBs3brT5nPj4eAQHB8Pd3R0tW7ZEamqqWF5SUoJHH30Uo0ePFvedOXMGnp6e+PLLLysd24ULF/DCCy/A29sbDRo0QO/evXHu3DmxfNiwYejTpw8+/PBD+Pv7o2HDhkhISLBZOiUvLw+xsbFwd3dHcHAwVqxYgWbNmuGjjz4CADRr1gwA0LdvXygUCvF9ma+//hrNmjWDl5cXBg4ciOvXr1c6/vshaULUrFkzKBSKcq+EhAQAd/5hExIS0LBhQ9SrVw/9+/dHQUGBzTFyc3MRGxsLDw8P+Pj4YMqUKeV+edPT0xEREQE3NzeEhIQgLS2tpk6xRjV7bcM9X0REriIlJQUpKSm4deuWuG/v3r1ISUnBTz/9ZFP3ww8/REpKCoqLi8V9Bw8eREpKCn744QebuqmpqUhJScHly5fFfVlZWfcV47Jly9CoUSMcOHAA48ePx9ixY/H888/jiSeewK+//ooePXpg8ODB4jlYrVY0adIEa9aswYkTJzB9+nT8+9//xurVqwEAderUwfLly7Fs2TJ8//33sFgseOmll/CPf/wDI0aMqFRMJpMJMTEx8PT0xM8//4y9e/eiXr166NmzJ4xGo1hv586dOHPmDHbu3Illy5YhLS3N5v46ZMgQXLp0Cenp6fjvf/+Lzz//HIWFhWL5wYMHAQBLly5FXl6e+B64k8StW7cO69evx/r167Fr1y7MmjXrvq5xZUmaEB08eBB5eXnia+vWrQCA559/HgAwceJE/Pjjj1izZg127dqFS5cuoV+/fuLPWywWxMbGwmg04pdffhH/QaZPny7WycnJQWxsLLp164asrCwkJiZi5MiR2Lx5c82eLBER0f9o27Yt3njjDbRo0QLJycmoU6cOGjVqhFGjRqFFixaYPn06rly5giNHjgC4M5/azJkz0bFjRwQHByMuLg7Dhw8XEyIAaNeuHd59912MHDkSiYmJOH/+PL744otKx/TNN9/AarVi8eLFCA8PR2hoKJYuXYrc3Fykp6eL9erXr4/58+ejVatWePbZZxEbG4vt27cDAE6ePIlt27bhiy++QGRkJCIiIrB48WLcvn1b/PnGjRsDALy9veHn5ye+B+4kfmlpaWjdujW6dOmCwYMHi8euLpL2Idx98gAwa9YsNG/eHE8++SSKi4uxZMkSrFixAk8//TSAO1lkaGgo9u3bh6ioKGzZsgUnTpzAtm3b4Ovri3bt2uGdd97BtGnTMGPGDGi1WixatAjBwcGYM2cOACA0NBR79uzBvHnzEBMTU+PnTDXLZDLhk08+AQCMHz+ekzMSuZDk5GQAtpOydurUCVFRUeXGFE6ePLlc3cceewwRERHl6k6YMKFc3ft9KqpNmzbitkqlQsOGDREeHi7u8/X1BQCblpVPP/0UX375JXJzc3H79m0YjcZynz9p0iSsW7cO8+fPx8aNG6s0H9tvv/2G06dPw9PT02Z/SUkJzpw5I75/9NFHoVKpxPf+/v44evQoACA7OxtqtRoRERFieUhICOrXr1+pGJo1a2bz+f7+/jbXoDo4zRgio9GI//znPxgxYgQUCgUyMzNhMpkQHR0t1mnVqhWCgoKQkZEBAMjIyEB4eLj4CwMAMTExMBgMOH78uFjn7mOU1Sk7hj2lpaUwGAw2L6qdBEHA9evXcf36dZv+fiKSP61WC61WazOTsUqlglarLTem0BF178f/fklTKBQ2+8o+w2q1AgBWrVqFyZMnIz4+Hlu2bEFWVhaGDx9u05UF3Emg/vjjD6hUKpw6dapKMd24cQMdOnRAVlaWzeuPP/7AoEGD/jb2sjgfVHUeuyJOM8p03bp1KCoqwrBhwwDcWb1Yq9XC29vbpp6vry/y8/PFOncnQ2XlZWV/V8dgMOD27dtwd3cvF0tKSgpmzpzpiNMiianVarz88sviNhFRbbZ371488cQTeOWVV8R9d7falBkxYgTCw8MRHx+PUaNGITo6GqGhoZX6jIiICHzzzTfw8fGBTqe7rzhbtmwJs9mMw4cPo0OHDgCA06dP49q1azb1NBqN00yJ4jQtREuWLMEzzzyDgIAAqUNBcnIyiouLxdeFCxekDonuk1KphJ+fH/z8/PjYPRHVei1atMChQ4ewefNm/PHHH3jzzTdtBiMDd7rUMjIysGzZMsTFxaFPnz6Ii4sr14pUkbi4ODRq1Ai9e/fGzz//jJycHKSnp+PVV1/FxYsXK3WMVq1aITo6GqNHj8aBAwdw+PBhjB49Gu7u7jYta82aNcP27duRn59fLlmqaU5xhzh//jy2bduGkSNHivv8/PxgNBpRVFRkU7egoAB+fn5inf996qzs/b3q6HQ6u61DAODm5gadTmfzIiIiktrLL7+Mfv36YcCAAYiMjMSVK1dsWotOnjyJKVOmYMGCBQgMDAQALFiwAH/99RfefPPNSn2Gh4cHdu/ejaCgIPTr1w+hoaGIj49HSUlJle6HX331FXx9fdG1a1f07dsXo0aNgqenJ+rUqSPWmTNnDrZu3YrAwEC0b9++0seuDgrBCQZWzJgxA5999hkuXLggdmsUFxejcePGWLlyJfr37w/gziCtVq1aISMjA1FRUdi4cSOeffZZ5OXlwcfHBwDw+eefY8qUKSgsLISbmxumTZuGn376SRzoBQCDBg3C1atXsWnTpkrFZzAY4OXlheLiYqdOjirzWP25WbE1EInzsFgs4r99eHj4fffzE5FzKikpQU5ODoKDg21utOR8Ll68iMDAQGzbtg3du3d32HH/7negKvdvyQdVWK1WLF26FEOHDrUZ4+Hl5YX4+HgkJSWhQYMG0Ol0GD9+PPR6PaKiogAAPXr0QFhYGAYPHozZs2cjPz8fb7zxBhISEuDm5gYAGDNmDObPn4+pU6dixIgR2LFjB1avXo0NGzgnjyuwWCz4/vvvAQBhYWFMiIiIasiOHTtw48YNhIeHIy8vD1OnTkWzZs3QtWtXqUOzS/KEaNu2bcjNzbU7YdS8efOgVCrRv39/lJaWIiYmBgsWLBDLVSoV1q9fj7Fjx0Kv16Nu3boYOnQo3n77bbFOcHAwNmzYgIkTJyI1NRVNmjTB4sWL+ci9i1AqlWjRooW4TURENcNkMuHf//43zp49C09PTzzxxBNYvny5005/4hRdZs6OXWZERM6JXWbkqC4zfmUmIqJaj9/tXZej/u2ZEBERUa1V1v1y93pl5FrKphN40DGiko8hIqpOJpMJixYtAnBngL2z9l0T0f1RqVTw9vYWl3Xw8PCwmeeG5M1qteLy5cvw8PB44Ml3mRCRrAmCgKtXr4rbRCQ/ZfPOVfdaV+SclEolgoKCHjgRZkJEsqZWqzF8+HBxm4jkR6FQwN/fHz4+PjCZTFKHQzVMq9U65Cli3iFI1sq+ORCR/KlUKs41RveNg6qJiIjI5bGFiGTNarXi999/BwCEhoZyckYiIrKLdweSNbPZjG+//RbffvstzGaz1OEQEZGTYgsRyZpCoUDTpk3FbSIiInuYEJGsaTQaDBs2TOowiIjIybHLjIiIiFweEyIiIiJyeewyI1kzmUxYsmQJACA+Pp5LdxARkV1MiEjWBEFAQUGBuE1ERGQPEyKSNbVajZdeekncJiIisod3CJI1pVKJ5s2bSx0GERE5OQ6qJiIiIpfHFiKSNavVitOnTwMAQkJCuHQHERHZxbsDyZrZbMbKlSuxcuVKLt1BREQVYgsRyZpCoUBAQIC4TUREZA8TIpI1jUaDUaNGSR0GERE5OXaZERERkctjQkREREQuj11mJGsmkwlff/01AGDw4MFcuoOIiOxiQkSyJggCLly4IG4TERHZw4SIZE2tVmPAgAHiNhERkT28Q5CsKZVKtGrVSuowiIjIyXFQNREREbk8thCRrFmtVuTm5gIAgoKCuHQHERHZxbsDyZrZbMayZcuwbNkyLt1BREQVYgsRyZpCoUDjxo3FbSIiInuYEJGsaTQavPLKK1KHQURETo5dZkREROTymBARERGRy2OXGcmayWTCqlWrAAADBw7k0h1ERGQXEyKSNUEQcPbsWXGbiIjIHiZEJGtqtRp9+/YVt4mIiOzhHYJkTalUok2bNlKHQURETk7yQdV//vknXnrpJTRs2BDu7u4IDw/HoUOHxHJBEDB9+nT4+/vD3d0d0dHROHXqlM0xrl69iri4OOh0Onh7eyM+Ph43btywqXPkyBF06dIFderUQWBgIGbPnl0j50dERETOT9KE6Nq1a+jUqRM0Gg02btyIEydOYM6cOahfv75YZ/bs2fj444+xaNEi7N+/H3Xr1kVMTAxKSkrEOnFxcTh+/Di2bt2K9evXY/fu3Rg9erRYbjAY0KNHDzRt2hSZmZn44IMPMGPGDHz++ec1er5U86xWK/7880/8+eefsFqtUodDREROSiFIONL0tddew969e/Hzzz/bLRcEAQEBAZg0aRImT54MACguLoavry/S0tIwcOBA/P777wgLC8PBgwfRsWNHAMCmTZvQq1cvXLx4EQEBAVi4cCFef/115OfnQ6vVip+9bt06nDx5stznlpaWorS0VHxvMBgQGBiI4uJi6HQ6R18Gh2n22oZ71jk3K7YGInEeRqMRKSkpAIDk5GTx35+IiOTPYDDAy8urUvdvSVuIfvjhB3Ts2BHPP/88fHx80L59e3zxxRdieU5ODvLz8xEdHS3u8/LyQmRkJDIyMgAAGRkZ8Pb2FpMhAIiOjoZSqcT+/fvFOl27drW5GcbExCA7OxvXrl0rF1dKSgq8vLzEV2BgoMPPnWqGQqEQ/x25dAcREVVE0oTo7NmzWLhwIVq0aIHNmzdj7NixePXVV7Fs2TIAQH5+PgDA19fX5ud8fX3Fsvz8fPj4+NiUq9VqNGjQwKaOvWPc/Rl3S05ORnFxsfi6cOGCA86WpKDRaJCYmIjExETOQURERBWS9Ckzq9WKjh074r333gMAtG/fHseOHcOiRYswdOhQyeJyc3ODm5ubZJ9PRERENUvSFiJ/f3+EhYXZ7AsNDUVubi4AwM/PDwBQUFBgU6egoEAs8/PzQ2FhoU252WzG1atXberYO8bdn0FERESuS9KEqFOnTsjOzrbZ98cff6Bp06YAgODgYPj5+WH79u1iucFgwP79+6HX6wEAer0eRUVFyMzMFOvs2LEDVqsVkZGRYp3du3fDZDKJdbZu3YqWLVvaPNFG8mM2m7Fq1SqsWrUKZrNZ6nCIiMhJSZoQTZw4Efv27cN7772H06dPY8WKFfj888+RkJAA4M6A2MTERLz77rv44YcfcPToUQwZMgQBAQHo06cPgDstSj179sSoUaNw4MAB7N27F+PGjcPAgQMREBAAABg0aBC0Wi3i4+Nx/PhxfPPNN0hNTUVSUpJUp041xGq1Ijs7G9nZ2XzsnoiIKiTpGKLHHnsMa9euRXJyMt5++20EBwfjo48+QlxcnFhn6tSpuHnzJkaPHo2ioiJ07twZmzZtQp06dcQ6y5cvx7hx49C9e3colUr0798fH3/8sVju5eWFLVu2ICEhAR06dECjRo0wffp0m7mKSJ5UKhWeffZZcZuIiMgeSechqi2qMo+BlDgPERER0f+v1sxDREREROQMuLgryZogCLh8+TIAoHHjxpyckYiI7GILEcmayWTCwoULsXDhQpunDImIiO7GFiKSPQ8PD6lDICIiJ8eEiGRNq9ViypQpUodBREROjl1mRERE5PKYEBEREZHLY5cZyZrZbMYPP/wAAPjXv/4FtZq/8kREVB5biEjWrFYrjh49iqNHj3LpDiIiqhC/LpOsqVQqxMTEiNtERET2MCEiWVOpVIiKipI6DCIicnLsMiMiIiKXxxYikjVBEFBcXAwA8PLy4tIdRERkF1uISNZMJhNSU1ORmprKpTuIiKhCbCEi2dNoNFKHQERETo4JEcmaVqvFv//9b6nDICIiJ8cuMyIiInJ5TIiIiIjI5bHLjGTNbDbjp59+AgD06tWLS3cQEZFdbCEiWbNarTh8+DAOHz7MpTuIiKhC/LpMsqZSqdCtWzdxm4iIyB4mRCRrKpUKXbt2lToMIiJycuwyIyIiIpfHFiKSNUEQcOvWLQCAh4cHl+4gIiK72EJEsmYymfDhhx/iww8/5NIdRERUISZERERE5PLYZUayptVq8dZbb0kdBhEROTm2EBEREZHLY0JERERELo9dZiRrZrMZ27ZtAwBER0dz6Q4iIrKLLUQka1arFfv378f+/fu5dAcREVWIX5dJ1lQqFTp37ixuExER2cOEiGRNpVKhe/fuUodBREROjl1mRERE5PLYQkSyJgiCOEO1RqPh0h1ERGQXW4hI1kwmE1JSUpCSksKlO4iIqEJMiIiIiMjlscuMZE2j0SA5OVncJiIiskfSFqIZM2ZAoVDYvFq1aiWWl5SUICEhAQ0bNkS9evXQv39/FBQU2BwjNzcXsbGx8PDwgI+PD6ZMmQKz2WxTJz09HREREXBzc0NISAjS0tJq4vTICSgUCmi1Wmi1Wo4fIiKiCkneZfboo48iLy9PfO3Zs0csmzhxIn788UesWbMGu3btwqVLl9CvXz+x3GKxIDY2FkajEb/88guWLVuGtLQ0TJ8+XayTk5OD2NhYdOvWDVlZWUhMTMTIkSOxefPmGj1PIiIicl6Sd5mp1Wr4+fmV219cXIwlS5ZgxYoVePrppwEAS5cuRWhoKPbt24eoqChs2bIFJ06cwLZt2+Dr64t27drhnXfewbRp0zBjxgxotVosWrQIwcHBmDNnDgAgNDQUe/bswbx58xATE1Oj50o1z2KxID09HQDw1FNPcXJGIiKyS/IWolOnTiEgIAAPP/ww4uLikJubCwDIzMyEyWRCdHS0WLdVq1YICgpCRkYGACAjIwPh4eHw9fUV68TExMBgMOD48eNinbuPUVan7Bj2lJaWwmAw2LyodrJYLNizZw/27NkDi8UidThEROSkJE2IIiMjkZaWhk2bNmHhwoXIyclBly5dcP36deTn50Or1cLb29vmZ3x9fZGfnw8AyM/Pt0mGysrLyv6ujsFgwO3bt+3GlZKSAi8vL/EVGBjoiNMlCSiVSkRGRiIyMhJKpeT5PxEROSlJu8yeeeYZcbtNmzaIjIxE06ZNsXr1ari7u0sWV3JyMpKSksT3BoOBSVEtpVar0bNnT6nDICIiJ+dUX5m9vb3xyCOP4PTp0/Dz84PRaERRUZFNnYKCAnHMkZ+fX7mnzsre36uOTqerMOlyc3ODTqezeREREZF8OVVCdOPGDZw5cwb+/v7o0KEDNBoNtm/fLpZnZ2cjNzcXer0eAKDX63H06FEUFhaKdbZu3QqdToewsDCxzt3HKKtTdgwiIiIiSROiyZMnY9euXTh37hx++eUX9O3bFyqVCi+++CK8vLwQHx+PpKQk7Ny5E5mZmRg+fDj0ej2ioqIAAD169EBYWBgGDx6M3377DZs3b8Ybb7yBhIQEuLm5AQDGjBmDs2fPYurUqTh58iQWLFiA1atXY+LEiVKeOtUQo9GImTNnYubMmTAajVKHQ0RETkrSMUQXL17Eiy++iCtXrqBx48bo3Lkz9u3bh8aNGwMA5s2bB6VSif79+6O0tBQxMTFYsGCB+PMqlQrr16/H2LFjodfrUbduXQwdOhRvv/22WCc4OBgbNmzAxIkTkZqaiiZNmmDx4sV85J6IiIhECkEQBKmDcHYGgwFeXl4oLi526vFEzV7bcM8652bF1kAkzkMQBNy6dQsA4OHhwdmqiYhcSFXu35JPzEhUnRQKBerWrSt1GERE5OScalA1ERERkRTYQkSyZrFYsHfvXgBAp06duHQHERHZxYSIZM1isWDnzp0AgKioKCZERERkFxMikjWlUon27duL20RERPYwISJZU6vV+Ne//iV1GERE5OT4lZmIiIhcHhMiIiIicnnsMiNZMxqN+PDDDwHcWSpGq9VKHBERETkjJkQkeyaTSeoQiIjIyTEhIlnTaDSYMGGCuE1ERGQPEyKSNYVCAW9vb6nDICIiJ8dB1UREROTy2EJEsmaxWHDw4EEAwGOPPcaZqomIyC4mRCRrFosFmzdvBgBEREQwISIiIruYEJGsKZVKhIeHi9tERET2MCEiWVOr1ejXr5/UYRARkZPjV2YiIiJyeUyIiIiIyOWxy4xkzWg0IjU1FQAwYcIELt1BRER2MSEi2bt165bUIRARkZNjQkSyptFoMHbsWHGbiIjIHiZEJGsKhQI+Pj5Sh0FERE6Og6qJiIjI5bGFyMU0e23DPeucmxVbA5HUDIvFgqysLABAu3btOFM1ERHZVeUWorNnz1ZHHETVwmKxYP369Vi/fj0sFovU4RARkZOqckIUEhKCbt264T//+Q9KSkqqIyYih1EqlWjZsiVatmzJpTuIiKhCVb5D/Prrr2jTpg2SkpLg5+eHl19+GQcOHKiO2IgemFqtxsCBAzFw4ECo1ewhJiIi+6qcELVr1w6pqam4dOkSvvzyS+Tl5aFz585o3bo15s6di8uXL1dHnERERETV5r77EMoWzVyzZg3ef/99nD59GpMnT0ZgYCCGDBmCvLw8R8ZJREREVG3uOyE6dOgQXnnlFfj7+2Pu3LmYPHkyzpw5g61bt+LSpUvo3bu3I+Mkui8mkwkfffQRPvroI5hMJqnDISIiJ1XlQRVz587F0qVLkZ2djV69euGrr75Cr169xAGrwcHBSEtLQ7NmzRwdK1GVCYKA4uJicZuIiMieKidECxcuxIgRIzBs2DD4+/vbrePj44MlS5Y8cHBED0qtVmPkyJHiNhERkT1VvkOcOnXqnnW0Wi2GDh16XwEROZJSqcRDDz0kdRhEROTkqjyGaOnSpVizZk25/WvWrMGyZcscEhQRERFRTapyQpSSkoJGjRqV2+/j44P33nvPIUEROYrVasWRI0dw5MgRWK1WqcMhIiInVeUus9zcXAQHB5fb37RpU+Tm5jokKCJHMZvNWLt2LQCgVatW0Gq1EkdERETOqMoJkY+PD44cOVLuKbLffvsNDRs2dFRcRA6hUCjw8MMPi9tERET2VDkhevHFF/Hqq6/C09MTXbt2BQDs2rULEyZMwMCBAx0eINGD0Gg0GDx4sNRhEBGRk6vyGKJ33nkHkZGR6N69O9zd3eHu7o4ePXrg6aeffqAxRLNmzYJCoUBiYqK4r6SkBAkJCWjYsCHq1auH/v37o6CgwObncnNzERsbCw8PD/j4+GDKlCkwm802ddLT0xEREQE3NzeEhIQgLS3tvuMkIiIi+alyQqTVavHNN9/g5MmTWL58Ob777jucOXMGX3755X2Pzzh48CA+++wztGnTxmb/xIkT8eOPP2LNmjXYtWsXLl26hH79+onlFosFsbGxMBqN+OWXX7Bs2TKkpaVh+vTpYp2cnBzExsaiW7duyMrKQmJiIkaOHInNmzffV6xEREQkPwpB4ul7b9y4gYiICCxYsADvvvsu2rVrh48++gjFxcVo3LgxVqxYgeeeew4AcPLkSYSGhiIjIwNRUVHYuHEjnn32WVy6dAm+vr4AgEWLFmHatGm4fPkytFotpk2bhg0bNuDYsWPiZw4cOBBFRUXYtGlTpWI0GAzw8vJCcXExdDqd4y+CgzR7bYNDjnNuVqxDjuMMTCYTvvjiCwDAqFGjoNFoJI6IiIhqSlXu31VuIbJYLFiyZAkGDRqE6OhoPP300zavqkpISEBsbCyio6Nt9mdmZsJkMtnsb9WqFYKCgpCRkQEAyMjIQHh4uJgMAUBMTAwMBgOOHz8u1vnfY8fExIjHsKe0tBQGg8HmRbWTIAi4fPkyLl++zKU7iIioQlUeVD1hwgSkpaUhNjYWrVu3fqAnd1atWoVff/0VBw8eLFeWn58PrVYLb29vm/2+vr7Iz88X69ydDJWVl5X9XR2DwYDbt2/D3d293GenpKRg5syZ931e5DzUarU4azqX7iAioopU+Q6xatUqrF69Gr169XqgD75w4QImTJiArVu3ok6dOg90LEdLTk5GUlKS+N5gMCAwMFDCiOh+KZVKLjRMRET3dF+DqkNCQh74gzMzM1FYWIiIiAio1Wqo1Wrs2rULH3/8MdRqNXx9fWE0GlFUVGTzcwUFBfDz8wMA+Pn5lXvqrOz9verodDq7rUMA4ObmBp1OZ/MiIiIi+apyQjRp0iSkpqY+8HiM7t274+jRo8jKyhJfHTt2RFxcnLit0Wiwfft28Weys7ORm5sLvV4PANDr9Th69CgKCwvFOlu3boVOp0NYWJhY5+5jlNUpOwbJm9VqxcmTJ3Hy5Eku3UFERBWqcpfZnj17sHPnTmzcuBGPPvpouad2vvvuu0odx9PTE61bt7bZV7duXTRs2FDcHx8fj6SkJDRo0AA6nQ7jx4+HXq9HVFQUAKBHjx4ICwvD4MGDMXv2bOTn5+ONN95AQkIC3NzcAABjxozB/PnzMXXqVIwYMQI7duzA6tWrsWGDY57IIudmNpvxzTffALjTFcqlO4iIyJ4qJ0Te3t7o27dvdcRSzrx586BUKtG/f3+UlpYiJiYGCxYsEMtVKhXWr1+PsWPHQq/Xo27duhg6dCjefvttsU5wcDA2bNiAiRMnIjU1FU2aNMHixYsRExNTI+dA0lIoFOL4Ly7dQUREFZF8HqLagPMQERER1T7VOg8RcKcbYtu2bfjss89w/fp1AMClS5dw48aN+zkcERERkaSq3GV2/vx59OzZE7m5uSgtLcU//vEPeHp64v3330dpaSkWLVpUHXESERERVZsqtxBNmDABHTt2xLVr12weW+/bt2+5p7mIpFa2dMcXX3wBk8kkdThEROSkqtxC9PPPP+OXX34p97ROs2bN8OeffzosMCJHEAQBly5dEreJiIjsqXJCZLVaYbFYyu2/ePEiPD09HRIUkaOo1Wq8+OKL4jYREZE9Ve4y69GjBz766CPxvUKhwI0bN/DWW2898HIeRI6mVCrxyCOP4JFHHoFSeV/PEBARkQuo8lfmOXPmICYmBmFhYSgpKcGgQYNw6tQpNGrUCCtXrqyOGImIiIiqVZUToiZNmuC3337DqlWrcOTIEdy4cQPx8fGIi4urcG0wIqlYrVbk5OQAuDNJJ1uJiIjInvsaVKFWq/HSSy85OhYihzObzfjPf/4DgEt3EBFRxaqcEH311Vd/Wz5kyJD7DobI0RQKBXx9fcVtIiIie6q8dEf9+vVt3ptMJty6dQtarRYeHh64evWqQwN0Bly6g4iIqPap1qU7rl27ZvO6ceMGsrOz0blzZw6qJiIiolrJISNMW7RogVmzZmHChAmOOBwRERFRjXLYTHVqtVqcEZjIWZhMJixfvhwAEBcXB41GI3FERETkjKqcEP3www827wVBQF5eHubPn49OnTo5LDAiRxAEAefPnxe3iYiI7KlyQtSnTx+b9wqFAo0bN8bTTz+NOXPmOCouIodQq9V47rnnxG0iIiJ77mstM6LaQqlU4tFHH5U6DCIicnKctpeIiIhcXpVbiJKSkipdd+7cuVU9PJFDWa1WXLx4EcCdZWe4dAcREdlT5YTo8OHDOHz4MEwmE1q2bAkA+OOPP6BSqRARESHW46zA5AzMZjOWLl0KgEt3EBFRxaqcEP3zn/+Ep6cnli1bJs5afe3aNQwfPhxdunTBpEmTHB4k0f1SKBRo0KCBuE1ERGRPlZfueOihh7Bly5ZyA1WPHTuGHj16yHIuIi7dQUREVPtU69IdBoMBly9fLrf/8uXLuH79elUPR0RERCS5KidEffv2xfDhw/Hdd9/h4sWLuHjxIv773/8iPj4e/fr1q44YiYiIiKpVlccQLVq0CJMnT8agQYNgMpnuHEStRnx8PD744AOHB0j0IMxmM1avXg0AeOGFFzg5IxER2VXlu4OHhwcWLFiADz74AGfOnAEANG/eHHXr1nV4cEQPymq14tSpU+I2ERGRPff9dTkvLw95eXno2rUr3N3dIQgCn+Ihp6NSqdC7d29xm4iIyJ4qJ0RXrlzBCy+8gJ07d0KhUODUqVN4+OGHER8fj/r163M9M3IqKpUK7dq1kzoMIiJyclUeVD1x4kRoNBrk5ubCw8ND3D9gwABs2rTJocERERER1YQqtxBt2bIFmzdvRpMmTWz2t2jRAufPn3dYYESOYLVaUVhYCADw8fHh0h1ERGRXle8ON2/etGkZKnP16lW4ubk5JCgiRzGbzfjss8/w2WefwWw2Sx0OERE5qSonRF26dMFXX30lvlcoFLBarZg9eza6devm0OCIHpRCoYCnpyc8PT056J+IiCpU5S6z2bNno3v37jh06BCMRiOmTp2K48eP4+rVq9i7d291xEh03zQaDZKSkqQOg4iInFyVW4hat26NP/74A507d0bv3r1x8+ZN9OvXD4cPH0bz5s2rI0YiIiKialWlFiKTyYSePXti0aJFeP3116srJiIiIqIaVaWESKPR4MiRI9UVC5HDmc1mrF27FsCddfi4dAcREdlT5S6zl156CUuWLKmOWIgczmq14sSJEzhx4gSX7iAiogpV+euy2WzGl19+iW3btqFDhw7l1jCbO3euw4IjelAqlQrPPPOMuE1ERGRPpRKiI0eOoHXr1lAqlTh27BgiIiIAAH/88YdNPT7WTM5GpVLh8ccflzoMIiJycpXqMmvfvj3++usvAMD58+fx7bffYufOneVeO3bsqNKHL1y4EG3atIFOp4NOp4Ner8fGjRvF8pKSEiQkJKBhw4aoV68e+vfvj4KCAptj5ObmIjY2Fh4eHvDx8cGUKVPKTcCXnp6OiIgIuLm5ISQkBGlpaVWKk4iIiOStUgmRt7c3cnJyAADnzp1z2FiMJk2aYNasWcjMzMShQ4fw9NNPo3fv3jh+/DiAO+um/fjjj1izZg127dqFS5cuoV+/fuLPWywWxMbGwmg04pdffsGyZcuQlpaG6dOni3VycnIQGxuLbt26ISsrC4mJiRg5ciQ2b97skHMg5yYIAq5cuYIrV65AEASpwyEiIielECpxlxg9ejS++uor+Pv7Izc3F02aNKlwPMbZs2cfKKAGDRrggw8+wHPPPYfGjRtjxYoVeO655wAAJ0+eRGhoKDIyMhAVFYWNGzfi2WefxaVLl+Dr6wsAWLRoEaZNm4bLly9Dq9Vi2rRp2LBhA44dOyZ+xsCBA1FUVFTpxWgNBgO8vLxQXFwMnU73QOdXnZq9tsEhxzk3K9Yhx3EGRqMRKSkpAIDk5GRotVqJIyIioppSlft3pcYQff755+jXrx9Onz6NV199FaNGjYKnp6dDgi1jsViwZs0a3Lx5E3q9HpmZmTCZTIiOjhbrtGrVCkFBQWJClJGRgfDwcDEZAoCYmBiMHTsWx48fR/v27ZGRkWFzjLI6iYmJFcZSWlqK0tJS8b3BYHDciVKN4xp7RER0L5V+yqxnz54AgMzMTEyYMMFhCdHRo0eh1+tRUlKCevXqYe3atQgLC0NWVha0Wi28vb1t6vv6+iI/Px8AkJ+fb5MMlZWXlf1dHYPBgNu3b8Pd3b1cTCkpKZg5c6ZDzo+kpdVq8dprr0kdBhERObkqz0O0dOlSh7YOtWzZEllZWdi/fz/Gjh2LoUOH4sSJEw47/v1ITk5GcXGx+Lpw4YKk8RAREVH1knzaXq1Wi5CQEABAhw4dcPDgQaSmpmLAgAEwGo0oKiqyaSUqKCiAn58fAMDPzw8HDhywOV7ZU2h31/nfJ9MKCgqg0+nstg4Bd7pY2M1CRETkOqrcQlTdrFYrSktL0aFDB2g0Gmzfvl0sy87ORm5uLvR6PQBAr9fj6NGjKCwsFOts3boVOp0OYWFhYp27j1FWp+wYJG9msxnr1q3DunXryk3HQEREVEbSFqLk5GQ888wzCAoKwvXr17FixQqkp6dj8+bN8PLyQnx8PJKSktCgQQPodDqMHz8eer0eUVFRAIAePXogLCwMgwcPxuzZs5Gfn4833ngDCQkJYgvPmDFjMH/+fEydOhUjRozAjh07sHr1amzY4Jgnssi5Wa1W/PbbbwCAXr16SRwNERE5K0kTosLCQgwZMgR5eXnw8vJCmzZtsHnzZvzjH/8AAMybNw9KpRL9+/dHaWkpYmJisGDBAvHnVSoV1q9fj7Fjx0Kv16Nu3boYOnQo3n77bbFOcHAwNmzYgIkTJyI1NRVNmjTB4sWLERMTU+PnSzVPpVKJTxly6Q4iIqpIpeYhcnWch4iIiKj2qcr92+nGEBERERHVNMmfMiOqToIg4Pr16wAAT09PLkBMRER2sYWIZM1kMmHevHmYN28eTCaT1OEQEZGTYgsRyZ5SybyfiIj+HhMikjWtVos333xT6jCIiMjJ8aszERERuTwmREREROTy2GVGsmY2m7F582YAQExMDNRq/soTEVF5bCEiWbNarTh06BAOHToEq9UqdThEROSk+HWZZE2lUuHJJ58Ut4mIiOxhQkTlVGYJkNqyvIdKpcJTTz0ldRhEROTk2GVGRERELo8tRCRrgiCgtLQUAODm5salO4iIyC62EJGsmUwmvP/++3j//fe5dAcREVWICRERERG5PHaZkaxpNBq88cYbALimGRERVYwJEcmaQqHg4/ZERHRPTIhqico8Ck9ERET3hwkRyZrFYsH27dsBAN27d2drERER2cVBFSRrFosFGRkZyMjIgMVikTocIiJyUmwhIllTqVTQ6/XiNhERkT1MiEjWVCoVevToIXUYRETk5NhlRkRERC6PLUQka4IgwGq1ArgzDxGX7iAiInuYEJGsmUwmpKSkAACSk5Oh1WoljoiIiJwRu8yIiIjI5bGFiGRNo9Fg2rRp4jYREZE9TIhI1hQKBerUqSN1GERE5OTYZUZEREQujy1EJGsWiwU///wzAKBLly6cnJGIiOxiQkSyZrFYsGvXLgDAE088wYSIiIjsYkJEsqZUKtGxY0dxm4iIyB4mRCRrarUasbGxUodBREROjl+ZiYiIyOUxISIiIiKXxy4zkjWj0Yj3338fADBt2jQu3UFERHYxISLZK1vclYiIqCJMiEjWNBoNJk6cKG4TERHZw4SIZE2hUECn00kdBhEROTlJB1WnpKTgscceg6enJ3x8fNCnTx9kZ2fb1CkpKUFCQgIaNmyIevXqoX///igoKLCpk5ubi9jYWHh4eMDHxwdTpkyB2Wy2qZOeno6IiAi4ubkhJCQEaWlp1X16REREVEtImhDt2rULCQkJ2LdvH7Zu3QqTyYQePXrg5s2bYp2JEyfixx9/xJo1a7Br1y5cunQJ/fr1E8stFgtiY2NhNBrxyy+/YNmyZUhLS8P06dPFOjk5OYiNjUW3bt2QlZWFxMREjBw5Eps3b67R86WaZ7FYsHfvXuzduxcWi0XqcIiIyEkpBEEQpA6izOXLl+Hj44Ndu3aha9euKC4uRuPGjbFixQo899xzAICTJ08iNDQUGRkZiIqKwsaNG/Hss8/i0qVL8PX1BQAsWrQI06ZNw+XLl6HVajFt2jRs2LABx44dEz9r4MCBKCoqwqZNm8rFUVpaitLSUvG9wWBAYGAgiouLJet+afbaBkk+tyLnZtWOyQ6NRiNSUlIAAMnJyXzKjIjIhRgMBnh5eVXq/u1U8xAVFxcDABo0aAAAyMzMhMlkQnR0tFinVatWCAoKQkZGBgAgIyMD4eHhYjIEADExMTAYDDh+/LhY5+5jlNUpO8b/SklJgZeXl/gKDAx03ElSjVIqlWjbti3atm3LpTuIiKhCTnOHsFqtSExMRKdOndC6dWsAQH5+PrRaLby9vW3q+vr6Ij8/X6xzdzJUVl5W9nd1DAYDbt++XS6W5ORkFBcXi68LFy445Byp5qnVavTp0wd9+vSBWs1nCIiIyD6nuUMkJCTg2LFj2LNnj9ShwM3NDW5ublKHQURERDXEKVqIxo0bh/Xr12Pnzp1o0qSJuN/Pzw9GoxFFRUU29QsKCuDn5yfW+d+nzsre36uOTqeDu7u7o0+HiIiIahlJEyJBEDBu3DisXbsWO3bsQHBwsE15hw4doNFosH37dnFfdnY2cnNzodfrAQB6vR5Hjx5FYWGhWGfr1q3Q6XQICwsT69x9jLI6Zccg+TIajZg1axZmzZoFo9EodThEROSkJO0yS0hIwIoVK/D999/D09NTHPPj5eUFd3d3eHl5IT4+HklJSWjQoAF0Oh3Gjx8PvV6PqKgoAECPHj0QFhaGwYMHY/bs2cjPz8cbb7yBhIQEsdtrzJgxmD9/PqZOnYoRI0Zgx44dWL16NTZscK4nt6h63P3EIBERkT2SPnavUCjs7l+6dCmGDRsG4M7EjJMmTcLKlStRWlqKmJgYLFiwQOwOA4Dz589j7NixSE9PR926dTF06FDMmjXLZhBteno6Jk6ciBMnTqBJkyZ48803xc+4l6o8tldd+Nj9/REEAVevXgVw5+nFin7niIhIfqpy/3aqeYicFROi8mpLQkRERK6r1s5DRERERCQFp3nsnqg6WCwWZGZmArgzSF+lUkkcEREROSMmRCRrFosFGzduBAC0a9eOCREREdnFhIhkTalUitMvcOkOIiKqCBMikjW1Wo3nn39e6jCIiMjJMSGi+1KZp974JBoREdUW7EMgIiIil8cWIpI1k8mETz75BAAwfvx4aDQaiSMiIiJnxISIZE0QBFy/fl3cJiIisocJEcmaWq3Gyy+/LG4TERHZwzsEyZpSqbRZ946IiMgeDqomIiIil8cWIpI1i8WCo0ePAgDCw8M5UzUREdnFhIhkzWKx4PvvvwcAhIWFMSEiIiK7mBCRrCmVSrRo0ULcJiIisocJEcmaWq3GoEGDpA6DiIicHL8yExERkctjQkREREQuj11mJGsmkwmLFi0CAIwZM4ZLdxARkV1MiEjWBEHA1atXxW0iIiJ7mBCRrKnVagwfPlzcJiIisod3CJI1pVKJoKAgqcMgIiInx0HVRERE5PLYQkSyZrVa8fvvvwMAQkNDOTkjERHZxbsDyZrZbMa3336Lb7/9FmazWepwiIjISbGFiKpNs9c23LPOuVmx1RqDQqFA06ZNxW0iIiJ7mBCRrGk0GgwbNkzqMIiIyMmxy4yIiIhcHhMiIiIicnnsMiNZM5lMWLJkCQAgPj6eS3cQEZFdTIhI1gRBQEFBgbhNRERkDxMikjW1Wo2XXnpJ3CYiIrKHdwiSNaVSiebNm0sdBhEROTkOqiYiIiKXxxYikjWr1YrTp08DAEJCQrh0BxER2cW7A8ma2WzGypUrsXLlSi7dQUREFWILEcmaQqFAQECAuE1ERGQPEyKSNY1Gg1GjRkkdBhEROTlJu8x2796Nf/7znwgICIBCocC6detsygVBwPTp0+Hv7w93d3dER0fj1KlTNnWuXr2KuLg46HQ6eHt7Iz4+Hjdu3LCpc+TIEXTp0gV16tRBYGAgZs+eXd2nRkRERLWIpAnRzZs30bZtW3z66ad2y2fPno2PP/4YixYtwv79+1G3bl3ExMSgpKRErBMXF4fjx49j69atWL9+PXbv3o3Ro0eL5QaDAT169EDTpk2RmZmJDz74ADNmzMDnn39e7edHREREtYNCcJLpexUKBdauXYs+ffoAuNM6FBAQgEmTJmHy5MkAgOLiYvj6+iItLQ0DBw7E77//jrCwMBw8eBAdO3YEAGzatAm9evXCxYsXERAQgIULF+L1119Hfn4+tFotAOC1117DunXrcPLkyUrFZjAY4OXlheLiYuh0OseffCU0e22DJJ9b3c7Niq3W45tMJnz99dcAgMGDB3PpDiIiF1KV+7fTPmWWk5OD/Px8REdHi/u8vLwQGRmJjIwMAEBGRga8vb3FZAgAoqOjoVQqsX//frFO165dxWQIAGJiYpCdnY1r167Z/ezS0lIYDAabF9VOgiDgwoULuHDhApfuICKiCjntoOr8/HwAgK+vr81+X19fsSw/Px8+Pj425Wq1Gg0aNLCpExwcXO4YZWX169cv99kpKSmYOXOmY06kEuTa+uMM1Go1BgwYIG4TERHZwzuEHcnJyUhKShLfGwwGBAYGShiRfFUmGXyQbjWlUolWrVrd988TEZFrcNouMz8/PwAQVyovU1BQIJb5+fmhsLDQptxsNuPq1as2dewd4+7P+F9ubm7Q6XQ2LyIiIpIvp02IgoOD4efnh+3bt4v7DAYD9u/fD71eDwDQ6/UoKipCZmamWGfHjh2wWq2IjIwU6+zevRsmk0mss3XrVrRs2dJudxnJi9Vqxblz53Du3DlYrVapwyEiIiclaUJ048YNZGVlISsrC8CdgdRZWVnIzc2FQqFAYmIi3n33Xfzwww84evQohgwZgoCAAPFJtNDQUPTs2ROjRo3CgQMHsHfvXowbNw4DBw4UZyceNGgQtFot4uPjcfz4cXzzzTdITU216RIj+TKbzVi2bBmWLVvGpTuIiKhCko4hOnToELp16ya+L0tShg4dirS0NEydOhU3b97E6NGjUVRUhM6dO2PTpk2oU6eO+DPLly/HuHHj0L17dyiVSvTv3x8ff/yxWO7l5YUtW7YgISEBHTp0QKNGjTB9+nSbuYpIvhQKBRo3bixuExER2eM08xA5s+qeh4hPmf296p6riIiI5EkW8xARERER1RQmREREROTyOA8RyZrJZMKqVasAAAMHDuTSHUREZBcTIpI1QRBw9uxZcZuIiMgeJkQka2q1Gn379hW3iYiI7OEdgmRNqVSiTZs2UodBREROjoOqiYiIyOWxhYic3oMsAGu1WpGXlwcA8Pf3h1LJ7wBERFQe7w4ka2azGYsXL8bixYu5dAcREVWILUQkawqFAl5eXuI2ERGRPUyISNY0Gg0SExOlDoOIiJwcu8yIiIjI5TEhIiIiIpfHLjOSNbPZjG+//RYA8Nxzz3FyRiIisot3B5KFih7NV8OCwe7ZAO48gk9ERGQPEyKSNQsU2GtsCgBQqVQSR0NERM6KCRHJmgAl/rA0BsCEiIiIKsZB1UREROTy2EJEMifAW1FyZ0sQODkjERHZxYSIZE0NK/rWOQ4AMJn+Ba1WK3FERETkjJgQkeyVCPw1JyKiv8c7BcmaGSqsLGkHAFg5fes965+bFVvNERERkTPioGoiIiJyeUyIiIiIyOWxy4xkTQUrOmnOAQD2mprBwu8ARERkB+8OJGsKCGiuvorm6qtQQJA6HCIiclJsISJZs0CB/cZAcfteKloT7W4ceE1EJD9MiEjWBChxwuIrdRhEROTk2GVGRERELo8tRCRzAuopjACAG4IWqES32b2wW42ISH7YQkSypoYVz9c5iufrHIUaVqnDISIiJ8UWIpI9k8C8n4iI/h4TIpI1M1T4T0lEjX8uu9WIiGoXfnUmIiIil8eEiIiIiFweu8xI1pSwIkqTCwDYZwqC1Ym+A7BbjYjIeTAhIllTQkBL9V8AgAOmwFr3nBmTJiKimsGEiGTNCgUyTQHithwxaSIienBMiEjWrFDiiDlA6jBkg8kXEcmVSyVEn376KT744APk5+ejbdu2+OSTT/D4449LHRZRtatMIlOTn8WkiYicjfOMMK1m33zzDZKSkvDWW2/h119/Rdu2bRETE4PCwkKpQ6NqJcANJrjBBECQOhgiInJSLpMQzZ07F6NGjcLw4cMRFhaGRYsWwcPDA19++aXUoVE1UsOKQe6/YZD7b1y6g4iIKuQSXWZGoxGZmZlITk4W9ymVSkRHRyMjI6Nc/dLSUpSWlorvi4uLAQAGg6Fa4rOW3qqW4xJghQUlipI726W3YIVK4ogIAIImrrlnnWMzY2ogEiKSs7L7tiDcu4fAJRKiv/76CxaLBb6+vjb7fX19cfLkyXL1U1JSMHPmzHL7AwMDqy1Gqj6zpA6A7ovXR1JHQERycf36dXh5ef1tHZdIiKoqOTkZSUlJ4nur1YqrV6+iYcOGUCgc8+i2wWBAYGAgLly4AJ1O55Bjkn281jWH17pm8DrXHF7rmlMd11oQBFy/fh0BAfd+2tglEqJGjRpBpVKhoKDAZn9BQQH8/PzK1Xdzc4Obm5vNPm9v72qJTafT8T9ZDeG1rjm81jWD17nm8FrXHEdf63u1DJVxiUHVWq0WHTp0wPbt28V9VqsV27dvh16vlzAyIiIicgYu0UIEAElJSRg6dCg6duyIxx9/HB999BFu3ryJ4cOHSx0aERERScxlEqIBAwbg8uXLmD59OvLz89GuXTts2rSp3EDrmuLm5oa33nqrXNccOR6vdc3hta4ZvM41h9e65kh9rRVCZZ5FIyIiIpIxlxhDRERERPR3mBARERGRy2NCRERERC6PCRERERG5PCZEEvj000/RrFkz1KlTB5GRkThw4IDUIdU6M2bMgEKhsHm1atVKLC8pKUFCQgIaNmyIevXqoX///uUm5szNzUVsbCw8PDzg4+ODKVOmwGw21/SpOJ3du3fjn//8JwICAqBQKLBu3TqbckEQMH36dPj7+8Pd3R3R0dE4deqUTZ2rV68iLi4OOp0O3t7eiI+Px40bN2zqHDlyBF26dEGdOnUQGBiI2bNnV/epOZV7Xedhw4aV+x3v2bOnTR1e58pJSUnBY489Bk9PT/j4+KBPnz7Izs62qeOovxnp6emIiIiAm5sbQkJCkJaWVt2n5zQqc52feuqpcr/XY8aMsakj2XUWqEatWrVK0Gq1wpdffikcP35cGDVqlODt7S0UFBRIHVqt8tZbbwmPPvqokJeXJ74uX74slo8ZM0YIDAwUtm/fLhw6dEiIiooSnnjiCbHcbDYLrVu3FqKjo4XDhw8LP/30k9CoUSMhOTlZitNxKj/99JPw+uuvC999950AQFi7dq1N+axZswQvLy9h3bp1wm+//Sb861//EoKDg4Xbt2+LdXr27Cm0bdtW2Ldvn/Dzzz8LISEhwosvviiWFxcXC76+vkJcXJxw7NgxYeXKlYK7u7vw2Wef1dRpSu5e13no0KFCz549bX7Hr169alOH17lyYmJihKVLlwrHjh0TsrKyhF69eglBQUHCjRs3xDqO+Jtx9uxZwcPDQ0hKShJOnDghfPLJJ4JKpRI2bdpUo+crlcpc5yeffFIYNWqUze91cXGxWC7ldWZCVMMef/xxISEhQXxvsViEgIAAISUlRcKoap+33npLaNu2rd2yoqIiQaPRCGvWrBH3/f777wIAISMjQxCEOzcjpVIp5Ofni3UWLlwo6HQ6obS0tFpjr03+90ZttVoFPz8/4YMPPhD3FRUVCW5ubsLKlSsFQRCEEydOCACEgwcPinU2btwoKBQK4c8//xQEQRAWLFgg1K9f3+ZaT5s2TWjZsmU1n5Fzqigh6t27d4U/w+t8/woLCwUAwq5duwRBcNzfjKlTpwqPPvqozWcNGDBAiImJqe5Tckr/e50F4U5CNGHChAp/RsrrzC6zGmQ0GpGZmYno6Ghxn1KpRHR0NDIyMiSMrHY6deoUAgIC8PDDDyMuLg65ubkAgMzMTJhMJpvr3KpVKwQFBYnXOSMjA+Hh4TYTc8bExMBgMOD48eM1eyK1SE5ODvLz822urZeXFyIjI22urbe3Nzp27CjWiY6OhlKpxP79+8U6Xbt2hVarFevExMQgOzsb165dq6GzcX7p6enw8fFBy5YtMXbsWFy5ckUs43W+f8XFxQCABg0aAHDc34yMjAybY5TVcdW/7/97ncssX74cjRo1QuvWrZGcnIxbt26JZVJeZ5eZqdoZ/PXXX7BYLOVmx/b19cXJkycliqp2ioyMRFpaGlq2bIm8vDzMnDkTXbp0wbFjx5Cfnw+tVltuQV5fX1/k5+cDAPLz8+3+O5SVkX1l18betbv72vr4+NiUq9VqNGjQwKZOcHBwuWOUldWvX79a4q9NevbsiX79+iE4OBhnzpzBv//9bzzzzDPIyMiASqXidb5PVqsViYmJ6NSpE1q3bg0ADvubUVEdg8GA27dvw93dvTpOySnZu84AMGjQIDRt2hQBAQE4cuQIpk2bhuzsbHz33XcApL3OTIioVnrmmWfE7TZt2iAyMhJNmzbF6tWrXeqPDsnXwIEDxe3w8HC0adMGzZs3R3p6Orp37y5hZLVbQkICjh07hj179kgdiqxVdJ1Hjx4tboeHh8Pf3x/du3fHmTNn0Lx585oO0wa7zGpQo0aNoFKpyj25UFBQAD8/P4mikgdvb2888sgjOH36NPz8/GA0GlFUVGRT5+7r7OfnZ/ffoayM7Cu7Nn/3O+zn54fCwkKbcrPZjKtXr/L6P4CHH34YjRo1wunTpwHwOt+PcePGYf369di5cyeaNGki7nfU34yK6uh0Opf6olbRdbYnMjISAGx+r6W6zkyIapBWq0WHDh2wfft2cZ/VasX27duh1+sljKz2u3HjBs6cOQN/f3906NABGo3G5jpnZ2cjNzdXvM56vR5Hjx61uaFs3boVOp0OYWFhNR5/bREcHAw/Pz+ba2swGLB//36ba1tUVITMzEyxzo4dO2C1WsU/fnq9Hrt374bJZBLrbN26FS1btnTJbpzKuHjxIq5cuQJ/f38AvM5VIQgCxo0bh7Vr12LHjh3luhEd9TdDr9fbHKOsjqv8fb/XdbYnKysLAGx+ryW7zg80JJuqbNWqVYKbm5uQlpYmnDhxQhg9erTg7e1tM6Ke7m3SpElCenq6kJOTI+zdu1eIjo4WGjVqJBQWFgqCcOcR2qCgIGHHjh3CoUOHBL1eL+j1evHnyx7t7NGjh5CVlSVs2rRJaNy4MR+7FwTh+vXrwuHDh4XDhw8LAIS5c+cKhw8fFs6fPy8Iwp3H7r29vYXvv/9eOHLkiNC7d2+7j923b99e2L9/v7Bnzx6hRYsWNo+DFxUVCb6+vsLgwYOFY8eOCatWrRI8PDxc6nHwv7vO169fFyZPnixkZGQIOTk5wrZt24SIiAihRYsWQklJiXgMXufKGTt2rODl5SWkp6fbPO5969YtsY4j/maUPQ4+ZcoU4ffffxc+/fRTl3rs/l7X+fTp08Lbb78tHDp0SMjJyRG+//574eGHHxa6du0qHkPK68yESAKffPKJEBQUJGi1WuHxxx8X9u3bJ3VItc6AAQMEf39/QavVCg899JAwYMAA4fTp02L57du3hVdeeUWoX7++4OHhIfTt21fIy8uzOca5c+eEZ555RnB3dxcaNWokTJo0STCZTDV9Kk5n586dAoByr6FDhwqCcOfR+zfffFPw9fUV3NzchO7duwvZ2dk2x7hy5Yrw4osvCvXq1RN0Op0wfPhw4fr16zZ1fvvtN6Fz586Cm5ub8NBDDwmzZs2qqVN0Cn93nW/duiX06NFDaNy4saDRaISmTZsKo0aNKvfFide5cuxdZwDC0qVLxTqO+puxc+dOoV27doJWqxUefvhhm8+Qu3td59zcXKFr165CgwYNBDc3NyEkJESYMmWKzTxEgiDddVb8fydBRERE5LI4hoiIiIhcHhMiIiIicnlMiIiIiMjlMSEiIiIil8eEiIiIiFweEyIiIiJyeUyIiIiIyOUxISIiIiKXx4SIiGqdp556ComJiVKHgfT0dCgUinKLghJR7cOEiIioEpwlCSOi6sGEiIiIiFweEyIiqtVKS0sxefJkPPTQQ6hbty4iIyORnp4ulqelpcHb2xubN29GaGgo6tWrh549eyIvL0+sYzab8eqrr8Lb2xsNGzbEtGnTMHToUPTp0wcAMGzYMOzatQupqalQKBRQKBQ4d+6c+POZmZno2LEjPDw88MQTTyA7O7uGzp6IHIUJERHVauPGjUNGRgZWrVqFI0eO4Pnnn0fPnj1x6tQpsc6tW7fw4Ycf4uuvv8bu3buRm5uLyZMni+Xvv/8+li9fjqVLl2Lv3r0wGAxYt26dWJ6amgq9Xo9Ro0YhLy8PeXl5CAwMFMtff/11zJkzB4cOHYJarcaIESNq5NyJyHHUUgdARHS/cnNzsXTpUuTm5iIgIAAAMHnyZGzatAlLly7Fe++9BwAwmUxYtGgRmjdvDuBOEvX222+Lx/nkk0+QnJyMvn37AgDmz5+Pn376SSz38vKCVquFh4cH/Pz8ysXxf//3f3jyyScBAK+99hpiY2NRUlKCOnXqVM+JE5HDMSEiolrr6NGjsFgseOSRR2z2l5aWomHDhuJ7Dw8PMRkCAH9/fxQWFgIAiouLUVBQgMcff1wsV6lU6NChA6xWa6XiaNOmjc2xAaCwsBBBQUFVPykikgQTIiKqtW7cuAGVSoXMzEyoVCqbsnr16onbGo3GpkyhUEAQBIfFcffxFQoFAFQ6mSIi58AxRERUa7Vv3x4WiwWFhYUICQmxednr2rLHy8sLvr6+OHjwoLjPYrHg119/tamn1WphsVgcGj8ROQ+2EBFRrfXII48gLi4OQ4YMwZw5c9C+fXtcvnwZ27dvR5s2bRAbG1up44wfPx4pKSkICQlBq1at8Mknn+DatWtiaw8ANGvWDPv378e5c+dQr149NGjQoLpOi4gkwBYiIqrVli5diiFDhmDSpElo2bIl+vTpg4MHD1Zp/M60adPw4osvYsiQIdDr9ahXrx5iYmJsBkVPnjwZKpUKYWFhaNy4MXJzc6vjdIhIIgrBkR3pREQyYLVaERoaihdeeAHvvPOO1OEQUQ1glxkRubzz589jy5YtePLJJ1FaWor58+cjJycHgwYNkjo0Iqoh7DIjIpenVCqRlpaGxx57DJ06dcLRo0exbds2hIaGSh0aEdUQdpkRERGRy2MLEREREbk8JkRERETk8pgQERERkctjQkREREQujwkRERERuTwmREREROTymBARERGRy2NCRERERC7v/wFadT0uwXSFWgAAAABJRU5ErkJggg=="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "length_list[0:10]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:28.598149Z",
     "start_time": "2025-03-08T08:03:28.594748Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[218, 189, 141, 550, 147, 43, 123, 562, 233, 130]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:28.604839Z",
     "start_time": "2025-03-08T08:03:28.598149Z"
    }
   },
   "cell_type": "code",
   "source": [
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "raw_text\n",
    "# 字符串变成一个又一单词的列表"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['hello', 'world'],\n",
       " ['tokenize', 'text', 'datas', 'with', 'batch'],\n",
       " ['this', 'is', 'a', 'test']]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:28.628059Z",
     "start_time": "2025-03-08T08:03:28.604839Z"
    }
   },
   "source": [
    "# Tokenizer类，将文本列表转化为索引列表，再喂给模型\n",
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx  #词表,单词到id\n",
    "        self.idx2word = idx2word  #词表，id到单词\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx  #填充，一个批次的文本长度不一致，需要填充\n",
    "        self.bos_idx = bos_idx  #开始\n",
    "        self.eos_idx = eos_idx  #结束\n",
    "        self.unk_idx = unk_idx  #未知，未出现在最高频词表中的词\n",
    "    \n",
    "    # 把文版放到列表中，然后调用encode方法，将文本列表转化为索引列表\n",
    "    def encode(self, text_list):    #text_list是一批次的文本列表，每个元素是一句话，每个单词用一个数字表示\n",
    "        \"\"\"\n",
    "        将文本列表转化为索引列表\n",
    "        :param text_list:当前批次的文本列表，必须是一个二维的字符串列表。跟上面的示例一样\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        max_length = min(self.max_length, 2 + max(\n",
    "            [len(text) for text in text_list]))  #最大长度，最大长度是500，但是如果句子长度小于500，就取句子长度（句子长度是当前批次中最长的），2是为了留出开始和结束的位置，也就是[BOS]和[EOS]\n",
    "        indices = []\n",
    "        for text in text_list:\n",
    "            index = [self.word2idx.get(word, self.unk_idx) for word in text]  #单词转化为id，未知的词用unk_idx代替\n",
    "            index = [self.bos_idx] + index + [self.eos_idx]  #添加开始和结束\n",
    "            if len(index) < max_length:\n",
    "                index = index + [self.pad_idx] * (max_length - len(index))  #填充0\n",
    "            else:\n",
    "                index = index[:max_length]  #如果句子长度大于500，就截断\n",
    "            indices.append(index)   # incies是一批次的索引列表\n",
    "        return torch.tensor(indices)  #二维列表转化为tensor\n",
    "\n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        \"\"\"\n",
    "        将索引列表转化为文本列表\n",
    "        :param indices_list:某批次的索引列表\n",
    "        :param remove_bos:\n",
    "        :param remove_eos:\n",
    "        :param remove_pad:\n",
    "        :param split:\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "\n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text)  #encode支持批量处理\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   1, 4825,  182,    3,    0,    0,    0])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   1,   14,    9,    6, 2181,    3,    0])\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:28.630942Z",
     "start_time": "2025-03-08T08:03:28.628059Z"
    }
   },
   "cell_type": "code",
   "source": [
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"decode text----------\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "decode text----------\n",
      "[BOS] hello world [EOS] [PAD] [PAD] [PAD]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[BOS] this is a test [EOS] [PAD]\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "code",
   "source": [
    "train_data[0:1]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:28.636687Z",
     "start_time": "2025-03-08T08:03:28.630942Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([list([1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4, 173, 36, 256, 5, 25, 100, 43, 838, 112, 50, 670, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 4536, 1111, 17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2025, 19, 14, 22, 4, 1920, 4613, 469, 4, 22, 71, 87, 12, 16, 43, 530, 38, 76, 15, 13, 1247, 4, 22, 17, 515, 17, 12, 16, 626, 18, 2, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2223, 5244, 16, 480, 66, 3785, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25, 1415, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 5952, 15, 256, 4, 2, 7, 3766, 5, 723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 2, 1029, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2071, 56, 26, 141, 6, 194, 7486, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 5535, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 1334, 88, 12, 16, 283, 5, 16, 4472, 113, 103, 32, 15, 16, 5345, 19, 178, 32])],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 23
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:28.643197Z",
     "start_time": "2025-03-08T08:03:28.636687Z"
    }
   },
   "source": [
    "# 看看训练集的数据\n",
    "tokenizer.decode(train_data[0:1], remove_bos=False, remove_eos=False, remove_pad=False)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\"]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 24
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集与 DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:29.440023Z",
     "start_time": "2025-03-08T08:03:28.643197Z"
    }
   },
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:  #字符串输出样本中，是否含有【BOS】和【EOS】，【PAD】\n",
    "            # 这里之所以要decode，是因为原始数据集中，，没有BOS和EOS，但是我们需要用到，所以要decode，再encode加上BOS和EOS \n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "\n",
    "def collate_fct(batch):\n",
    "    \"\"\"\n",
    "    将batch数据处理成tensor形式\n",
    "    :param batch:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    text_list = [item[0].split() for item in batch]  #batch是128样本，每个样本类型是元组，第一个元素是文本，第二个元素是标签\n",
    "    label_list = [item[1] for item in batch]\n",
    "    text_list = tokenizer.encode(text_list).to(dtype=torch.int)  # 文本转化为索引\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "train_ds = IMDBDataset(train_data, train_labels)\n",
    "test_ds = IMDBDataset(test_data, test_labels)"
   ],
   "outputs": [],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:29.443611Z",
     "start_time": "2025-03-08T08:03:29.440023Z"
    }
   },
   "source": [
    "batch_size = 128 #batch_size越大，训练速度越快，但是内存占用也越大\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)  #collate_fn是处理batch的函数\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ],
   "outputs": [],
   "execution_count": 26
  },
  {
   "cell_type": "code",
   "source": [
    "#要看到每个batch的长度不同，需要修改batch_size为12\n",
    "i=0\n",
    "for text, label in train_dl:\n",
    "    print(text.shape, label.shape)\n",
    "    i+=1\n",
    "    if i==50:\n",
    "        break"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:42:11.515575Z",
     "start_time": "2025-03-08T08:42:11.092970Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n",
      "torch.Size([128, 500]) torch.Size([128, 1])\n"
     ]
    }
   ],
   "execution_count": 40
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义模型"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:29.916775Z",
     "start_time": "2025-03-08T08:03:29.913097Z"
    }
   },
   "cell_type": "code",
   "source": "(128,500,10000)",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(128, 500, 10000)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 28
  },
  {
   "cell_type": "code",
   "source": [
    "# target output size of 5\n",
    "m = nn.AdaptiveAvgPool1d(1)  # 自适应平均池化\n",
    "input = torch.randn(1, 3, 9)\n",
    "output = m(input)\n",
    "output.size()  #可以看到最后一维变成了1"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:29.929689Z",
     "start_time": "2025-03-08T08:03:29.917780Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 1])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 29
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:29.936541Z",
     "start_time": "2025-03-08T08:03:29.929689Z"
    }
   },
   "source": [
    "class AddingModel(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size):\n",
    "        super(AddingModel, self).__init__()\n",
    "        # vocab_size, embedding_dim: 10000, 16.\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)  # 词嵌入4\n",
    "        self.pool = nn.AdaptiveAvgPool1d(1)  # 自适应平均池化\n",
    "        self.layer = nn.Linear(embedding_dim, hidden_dim)  # 全连接层，进行特征放大 16 -> 64\n",
    "        self.fc = nn.Linear(hidden_dim, 1)  # 全连接层\n",
    "    \n",
    "    # 正向传播，\n",
    "    def forward(self, x):\n",
    "        # [bs, seq length] [128, 500] --->[128,500,16]\n",
    "        x = self.embeding(x)\n",
    "        # 用16个密集向量来代表每个单词，每个样本的长度是500，，交换维度后再求平均，[128,500,16]-->[128,16,500]，用16个密集向量来代表每个样本\n",
    "        x = x.permute(0, 2, 1)\n",
    "        # self.pool,对最后一维进行平均池化，[128,16,500]-->[128,16,1]\n",
    "        x = self.pool(x)  \n",
    "        # z.squeeze(2),将最后一维去掉，[128,16,1]-->[128,16]\n",
    "        x=x.squeeze(2)  # \n",
    "        # [bs, embedding_dim] -> [bs, hidden_dim]\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)  # [bs, hidden_dim] -> [bs, 1]\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "for key, value in AddingModel().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            embeding.weight             paramerters num: 160000\n",
      "              layer.weight              paramerters num: 1024\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 30
  },
  {
   "cell_type": "code",
   "source": [
    "16 * 64"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:29.940736Z",
     "start_time": "2025-03-08T08:03:29.936541Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 31
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "随机一个tensor做上面模型的前向计算"
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:30.219867Z",
     "start_time": "2025-03-08T08:03:29.940736Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 32
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:30.323512Z",
     "start_time": "2025-03-08T08:03:30.219867Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "\n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\",\n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "        )\n",
    "\n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "\n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "\n",
    "        )\n",
    "\n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 33
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:30.327612Z",
     "start_time": "2025-03-08T08:03:30.323512Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 34
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:03:30.334520Z",
     "start_time": "2025-03-08T08:03:30.327612Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else:\n",
    "            self.counter += 1\n",
    "\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 35
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:05:01.574295Z",
     "start_time": "2025-03-08T08:03:30.334520Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0 #当sigmoid输出大于0.5时，预测为1，否则预测为0，这里大于0，刚好sigmoid的值是0.5，预测为1\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n",
    "\n",
    "\n",
    "epoch = 20\n",
    "\n",
    "model = AddingModel()\n",
    "\n",
    "# 1. 定义损失函数 采用二进制交叉熵损失, 先sigmoid再计算交叉熵\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# loss_fct =nn.BCEWithLogitsLoss()\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-adding\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-adding\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_dl,\n",
    "    test_dl,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    ")"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/3920 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "c1cc18e4a63b47889db9e0f9c6b58e08"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 18 / global_step 3528\n"
     ]
    }
   ],
   "execution_count": 36
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:05:01.680551Z",
     "start_time": "2025-03-08T08:05:01.575311Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 37
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-08T08:05:03.945771Z",
     "start_time": "2025-03-08T08:05:01.680551Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-adding/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3084\n",
      "accuracy: 0.8814\n"
     ]
    }
   ],
   "execution_count": 38
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
